package OODay02_Day08;
//继承
/**生活中的继承
        * 集成财产 不是自己挣得 但是自己也能花
        * 继承王位 不是自己打下的江山 自己也能坐
        * 软件中的继承
          代码不用自己写  自己也能用... ...*/
//         ??不用自己??  自己也能??
public class Day08 {
    public static void main(String[] args) {
        //背景 代码重复
        //extends 继承(关键字 翻译为<扩展>)
        //作用 实现了<代码复用>

        //超类/基类/父类 被继承的类 共有的属性和行为
        //派生类/子类 调用超类 特有的属性和行为

        //派生类可以访问自己派生类的和超类 超类不能访问派生类
        //单一继承(只能继承一个超类) 一个超类可以有多个派生类 一个派生类只能有一个超类

        //继承具有传递性
        /**class Aoo{-------------------------只能访问a 无法访问它的子类
         int a;
         }
         class Boo extends Aoo{----------------能访问b,a 访问自己和父类的 无法访问它的子类 相当于b中有a,b两个变量
         int b;
         }
         class Coo extends Boo{----------------能访问c,b,a 相当于有a,b,c三个变量 继承即使没写在一起也可以拿来用
         int c;
         }*/


        //super关键字
        //作用 指代当前对象的超类对象(类似this this指代的是自己的)
        //super.成员变量名: 访问超类的成员变量
        //用的很少 只在父类 子类的变量名重名时 需要用this. super.区分子类 父类
           //若父类子类重名 可以直接将子类的变量移动到父类里储存
        //若不写前缀 则遵从就近原则

        //super.方法名()
        //super()

        //Java规定 构造派生类之前必须先构造超类
        //为了保证此规定 Java有两个操作
        //1 在派生类的构造方法中若没有调用超类的构造方法 则默认有一个super()帮助调用超类无参构造方法
        //super()调用超类构造方法必须位于派生类构造方法的第一行
        //2 在派生类的构造方法中若自己调用了超类的构造方法 则不再默认提供无参构造了

        //方法的重写(Overriding/Overrides)
        //java中的方法默认是可以进行重写的
        //背景 1 前提 子类中方法已经存在了(继承);2 目前方法不合适(继承过来的方法无法满足需求)

        //判断是否重写
        //发生在<父子类>中,方法名相同 参数列表也相同
        //例如 Student类里有Person类里的sayHi()方法 此时在子类中调用该方法 子类中特有的内容得不到表达
        // 此时重写一个sayHi()方法 把特有的成员变量写入方法
        //此时 子类重写了父类的方法 左侧会有相关提示

        //重写方法被调用时 看<对象>的类型来执行方法(new谁就调用谁)

        //若重写时想要在父类基础之上改善 子类在重写父类的方法时 可以通过super关键字调用父类的版本
        /**
         class 父类{
         void 父类(){
         System.out.println("父类行为");
         }
         }
         class 子类 extends 父类{
         void 父类(){
         super.父类();
         System.out.println("子类行为");
         }
         }*/

        //final(次重点)
        //表示最终的 最后的 意味着无法更改

        //特点
        //1 修饰变量:变量不能被改变
        //2 修饰方法:方法不能被重写
        //3 修饰类(类的改变即为继承 扩展):类不能被继承 但是能继承别的类(不能当爹只能当儿子)

        //应用率很低 违背了许多语法的特点
        //例如 int a=5;
        // a=10;----可以后续更改
        //final int a=5;
        //a=10;--编译错误 不可更改

        //class Foo{
        // final void a(){}
        // }
        //class Goo extends Foo{
        // void a(){}--------编译错误 不可重写
        // }

        //final class Hoo{}---------------不可被继承
        //class Ioo extends Hoo{}---------编译错误 无法继承被final修饰的类
        //final class Joo extends Ioo{}---正确 不能当父类 只能当子类

        //特殊应用场景
        //Java对包装类的限制用到了final:包装类里有许多都被做成final的形式了

        //常见的被final修饰的类
        // String
        // Math
        // Integer

        //补充
        //1 泛化:(其实就是继承 只是讨论角度不同)
        //从程序<设计>角度而言叫泛化 从代码<实现>的角度而言叫继承 泛化就是继承
        //2 java中的继承 要符合is(是)的关系---学生,老师,医生等等是人 都可以继承人类 同理动物类 水果类也是如此
        //(类间关系 继承 关联 组合 聚合......继承只是其中一种)
        //3 继承的是父类的成员变量和普通方法 不包括构造方法 父类构造方法是被子类通过super调用的
        //4 (面试题)重载和重写之间的区别
        //重写(overriding) 发生在父子类中 方法名相同 参数列表相同 表示延续并且改进某方法
        //重载(overloading) 发生在同一类中 方法名相同 参数类型不同 表示同一类型方法 提供不同的参数类型选择
        //5重载特例情况
        //不同类中也可能重载 (父子类)
       /** class Aoo {
            void show() {
            }
        }
        class Boo {
            void show(String name) {---------此时未发生重写或重载
            }
        }

        class Aoo {
            void show() {--------------------父类为发生重载 因为父类不可访问子类
            }
        }
        class Boo extends Aoo {
            void show(String name) {---------此时在子类中发生了重载 继承后子类拥有了父类的方法
            }

        }*/
    }
}
